home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Lose Your Marbles! 1.0 / source / Shell ƒ / integrity.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  5.4 KB  |  153 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        integrity.c
  4.  
  5. Purpose:    This module implements a quick-and-dirty integrity check:
  6.             compare the resource fork and map length to stored values.
  7.  
  8. This program is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2 of the License, or
  11. (at your option) any later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program in a file named "GNU General Public License".
  20. If not, write to the Free Software Foundation, 675 Mass Ave,
  21. Cambridge, MA 02139, USA.
  22.  
  23. \**********************************************************************/
  24.  
  25. #include "integrity.h"
  26. #include "util.h"
  27.  
  28. #define RESOURCE_FORK_DATA_LENGTH_OFFSET        8L
  29. #define RESOURCE_FORK_MAP_LENGTH_OFFSET            12L
  30. #define STORED_DATA_LENGTH_OFFSET                128L
  31. #define STORED_MAP_LENGTH_OFFSET                132L
  32. #define TAG_OFFSET                                136L
  33. #define THE_TAG                                    0x16435934
  34.  
  35. Boolean DoIntegrityCheck(Boolean *programIntegritySet)
  36. /* called first thing; can be used either to check program integrity (if it has
  37.    been installed) or to install the integrity checker (if the SHIFT key is
  38.    help down during program launch).  Returns FALSE if program integrity is
  39.    not verified; programIntegritySet is TRUE if this procedure installs the
  40.    integrity checker. */
  41. {
  42.     short            thisFile;
  43.     long            count;
  44.     long            resDataLength, checkData;
  45.     long            resMapLength, checkMap;
  46.     long            resMapOffset;
  47.     short            resAttributes;
  48.     long            tag;
  49.     KeyMap            rawKeys;
  50.     unsigned short    theKeys[8];
  51.     
  52.     *programIntegritySet=FALSE;
  53.     GetKeys(rawKeys);
  54.     Mymemcpy((Ptr)theKeys, (Ptr)rawKeys, sizeof(rawKeys));
  55.     FlushVol(0L, 0);        /* just to be on the safe side */
  56.     
  57.     /* interestingly enough, the new-and-improved functions to open a resource fork
  58.        (HOpenRF & FSpOpenRF) won't work here.  They check permissions and won't
  59.        allow write permission to an already-open resource fork -- so we won't be
  60.        able to install the integrity checker on the fly if we Do The Right Thing™.
  61.        Luckily, the old-and-inferior function (OpenRF) doesn't ask permission... */
  62.     OpenRF(CurApName, 0, &thisFile);
  63.     
  64.     SetFPos(thisFile, 1, RESOURCE_FORK_DATA_LENGTH_OFFSET);
  65.     count=4L;
  66.     /* get length of resource data */
  67.     if (FSRead(thisFile, &count, (Ptr)(&resDataLength))!=noErr)
  68.         return FALSE;
  69.     
  70.     SetFPos(thisFile, 1, RESOURCE_FORK_MAP_LENGTH_OFFSET);
  71.     count=4L;
  72.     /* get length of resource map */
  73.     if (FSRead(thisFile, &count, (Ptr)(&resMapLength))!=noErr)
  74.         return FALSE;
  75.     
  76.     SetFPos(thisFile, 1, TAG_OFFSET);
  77.     count=4L;
  78.     FSRead(thisFile, &count, (Ptr)(&tag));    /* read long-word tag */
  79.     if (tag!=THE_TAG)    /* if not equal to our tag, integrity checker not installed */
  80.     {
  81.         if (theKeys[3]&1)    /* if SHIFT key down, install integrity checker */
  82.         {
  83.             count=4L;
  84.             SetFPos(thisFile, 1, 4L);
  85.             /* get the offset of the start of the resource map in the resource fork */
  86.             if (FSRead(thisFile, &count, (Ptr)(&resMapOffset))!=noErr)
  87.                 return FALSE;
  88.             
  89.             resMapOffset+=22L;    /* resource fork attributes at map+22 */
  90.             count=2L;
  91.             SetFPos(thisFile, 1, resMapOffset);
  92.             /* get old resource fork attributes */
  93.             if (FSRead(thisFile, &count, (Ptr)(&resAttributes))!=noErr)
  94.                 return FALSE;
  95.             
  96.             resAttributes|=0x8000;    /* lock resource fork */
  97.             count=2L;
  98.             SetFPos(thisFile, 1, resMapOffset);
  99.             /* rewrite new resource fork attributes */
  100.             /* It is a little-known fact that this trick makes the application
  101.                immune to all known viruses -- no known virus bothers to unlock the
  102.                resource fork before attempting to infect, and ABSOLUTELY NO changes
  103.                can be made to the resource fork when it's locked like this.  On the
  104.                other hand, you better be damn sure that the application has no
  105.                viruses in it when you install the integrity checker -- if it's
  106.                infected when this code is run, you won't be able to disinfect it
  107.                until you unlock the resource fork. */
  108.             if (FSWrite(thisFile, &count, (Ptr)(&resAttributes))!=noErr)
  109.                 return FALSE;
  110.             
  111.             SetFPos(thisFile, 1, STORED_DATA_LENGTH_OFFSET);
  112.             count=4L;
  113.             /* store length of resource data */
  114.             if (FSWrite(thisFile, &count, (Ptr)(&resDataLength))!=noErr)
  115.                 return FALSE;
  116.             
  117.             SetFPos(thisFile, 1, STORED_MAP_LENGTH_OFFSET);
  118.             count=4L;
  119.             /* store length of resource map */
  120.             if (FSWrite(thisFile, &count, (Ptr)(&resMapLength))!=noErr)
  121.                 return FALSE;
  122.             
  123.             SetFPos(thisFile, 1, TAG_OFFSET);
  124.             count=4L;
  125.             tag=THE_TAG;
  126.             /* store tag so we know integrity checker is installed */
  127.             if (FSWrite(thisFile, &count, (Ptr)(&tag))!=noErr)
  128.                 return FALSE;
  129.             
  130.             *programIntegritySet=TRUE;        /* so we know we've installed it */
  131.         }
  132.         
  133.         return TRUE;
  134.     }
  135.     else
  136.     {
  137.         SetFPos(thisFile, 1, STORED_DATA_LENGTH_OFFSET);
  138.         count=4L;
  139.         /* get stored resource data length */
  140.         if (FSRead(thisFile, &count, (Ptr)(&checkData))!=noErr)
  141.             return FALSE;
  142.         
  143.         SetFPos(thisFile, 1, STORED_MAP_LENGTH_OFFSET);
  144.         count=4L;
  145.         /* get stored resource map length */
  146.         if (FSRead(thisFile, &count, (Ptr)(&checkMap))!=noErr)
  147.             return FALSE;
  148.         
  149.         /* check real resource data/map lengths to stored values */
  150.         return ((resDataLength==checkData) && (resMapLength==checkMap));
  151.     }
  152. }
  153.